import fs from 'fs/promises';
import path from 'path';
import { config } from '../../config';
import { Message } from '../../config/types';

/**
 * 聊天记录持久化存储类
 * 提供会话管理、历史记录存储和备份功能
 */
export class ChatStorage {
  private readonly storageDir: string;
  private readonly sessionId: string;
  private readonly maxBackups: number;

  /**
   * 初始化存储实例
   * @constructor
   * 1. 设置存储目录路径
   * 2. 生成唯一会话ID
   * 3. 设置最大备份数量
   * 4. 确保存储目录存在
   */
  constructor() {
    this.storageDir = path.join(__dirname, '..', config.CHAT_HISTORY_DIR);
    this.sessionId = this.generateSessionId();
    this.maxBackups = config.MAX_HISTORY_BACKUPS;
    this.ensureDirExists().catch(console.error);
  }

  /**
   * 创建存储目录（如果不存在）
   * @private
   * @returns Promise<void>
   */
  private async ensureDirExists(): Promise<void> {
    try {
      await fs.mkdir(this.storageDir, { recursive: true });
    } catch (error) {
      console.error('无法创建存储目录:', error);
    }
  }

  /**
   * 生成唯一会话ID
   * @private
   * @returns 格式：session_时间戳_随机数
   */
  private generateSessionId(): string {
    return `session_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
  }

  /**
   * 获取当前会话文件路径
   * @private
   * @returns 完整文件路径
   */
  private get sessionFile(): string {
    return path.join(this.storageDir, `${this.sessionId}.json`);
  }

  /**
   * 保存聊天记录到文件系统
   * @param messages - 要保存的消息数组
   * @returns Promise<void>
   */
  public async saveHistory(messages: Message[]): Promise<void> {
    try {
      const data = {
        meta: {
          created: new Date().toISOString(),
          messageCount: messages.length
        },
        messages
      };

      // 写入当前会话文件
      await fs.writeFile(this.sessionFile, JSON.stringify(data, null, 2));
      
      // 执行备份轮转策略
      await this.rotateBackups();
    } catch (error) {
      console.error('历史保存失败:', error);
    }
  }

  /**
   * 加载最近的历史会话
   * @returns Promise<Message[]> 消息数组（失败时返回空数组）
   */
  public async loadLatestSession(): Promise<Message[]> {
    try {
      const files = await fs.readdir(this.storageDir);
      
      // 过滤并排序会话文件
      const sessions = files
        .filter(f => f.endsWith('.json'))
        .sort() // 按文件名升序排序
        .reverse(); // 获取最新文件

      if (sessions.length === 0) return [];

      // 读取最新文件内容
      const latest = path.join(this.storageDir, sessions[0]);
      const data = await fs.readFile(latest, 'utf-8');
      return JSON.parse(data).messages;
    } catch (error) {
      console.error('加载历史失败:', error);
      return [];
    }
  }

  /**
   * 备份轮转策略
   * 保持最多 maxBackups 个备份文件
   * @private
   * @returns Promise<void>
   */
  private async rotateBackups(): Promise<void> {
    try {
      const files = await fs.readdir(this.storageDir);
      
      // 获取所有会话文件并按时间排序（旧→新）
      const sessionFiles = files
        .filter(f => f.endsWith('.json'))
        .sort() // 自然升序排序（旧文件在前）

      // 删除超出数量的旧备份
      while (sessionFiles.length > this.maxBackups) {
        const oldFile = sessionFiles.shift(); // 获取最旧的文件
        if (oldFile) {
          await fs.unlink(path.join(this.storageDir, oldFile));
        }
      }
    } catch (error) {
      console.error('备份轮转失败:', error);
    }
  }

  /**
   * 导出最近会话到指定路径
   * @param filePath - 目标文件路径
   * @returns Promise<void>
   */
  public async exportToJSON(filePath: string): Promise<void> {
    try {
      const messages = await this.loadLatestSession();
      await fs.writeFile(filePath, JSON.stringify(messages, null, 2));
    } catch (error) {
      console.error('导出失败:', error);
    }
  }
  // 是否有会话记录
  public async hasPreviousSession(): Promise<boolean> {
    try {
      const files = await fs.readdir(this.storageDir);
      return files.some(f => f.endsWith('.json'));
    } catch {
      return false;
    }
  }
  // 新增清空当前会话方法
  public async clearCurrentSession(): Promise<void> {
    try {
      // 添加文件存在性检查
      await fs.access(this.sessionFile); // 是否存在
      await fs.unlink(this.sessionFile);
    } catch (error:any) {
      // 忽略文件不存在的错误
      if (error.code !== 'ENOENT') {
        console.error('会话清除失败:', error);
      }
    }
  }
  
}
